﻿using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Web.UI;
using Duet.Web.Util.MasterPages;
using Duet.Model.Core.Entities;
using System.Web;
using System.Web.UI.WebControls;
using Image = System.Drawing.Image;
using System.Drawing;

namespace Duet.Web.Core
{
    /// <summary>
    ///     Gerenciador de conteúdo das páginas.
    /// </summary>
    public static class ContentManager
    {
        #region Métodos

        /// <summary>
        /// Obtém a página atual para anexação de scripts.
        /// </summary>
        /// <returns>Objeto <see cref="Page"/>.</returns>
        public static Page GetCurrentPage()
        {
            return (System.Web.UI.Page)System.Web.HttpContext.Current.Handler;
        }

        /// <summary>
        /// Obtém a Master Page principal, independente de quaisquer Master Pages internas existentes.
        /// </summary>
        public static Main GetMainMasterPage()
        {
            Page p = GetCurrentPage();
            Main master = null;

            if (p.Master != null && p.Master is Main)
            {
                master = (Main)p.Master;
            }
            else if ((p.Master.Master != null) && p.Master.Master is Main)
            {
                master = (Main)p.Master.Master;
            }

            return master;
        }

        /// <summary>
        /// Indica se a página atual está em uma requisição assíncrona.
        /// </summary>
        /// <returns>Valor booleano indicando se a página está em uma requisição assíncrona.</returns>
        public static bool IsInAsyncPostBack()
        {
            return GetMainMasterPage().GetMainScriptManager().IsInAsyncPostBack;
        }

        /// <summary>
        /// Executa códigos JavaScript na inicialização da página.
        /// </summary>
        /// <param name="script">Código JavaScript a sere executado no cliente.</param>
        /// <remarks>As tags script são adicionadas automaticamente.</remarks>
        public static void RunStartupScript(string script, bool isLogged)
        {
            if (isLogged)
            {
                if (IsInAsyncPostBack())
                {
                    ScriptManager.RegisterStartupScript(GetCurrentPage(),
                        GetCurrentPage().GetType(),
                        Guid.NewGuid().ToString(),
                        script,
                        true);
                }
                else
                {
                    GetCurrentPage().ClientScript.RegisterStartupScript(GetCurrentPage().GetType(),
                        Guid.NewGuid().ToString(),
                        script,
                        true);
                }
            }
            else
            {
                GetCurrentPage().ClientScript.RegisterStartupScript(GetCurrentPage().GetType(),
                    Guid.NewGuid().ToString(),
                    script,
                    true);
            }

        }

        /// <summary>
        /// Escreve e exibe um arquivo Excel (XLS)
        /// </summary>
        /// <param name="control">Controle a ser renderizado para gerar conteúdo do XLS</param>
        /// <param name="filename">Nome de sugestão para o arquivo de Download</param>
        public static void WriteExcel(Control control, string filename, bool endExecution)
        {
            StringWriter sw = new StringWriter();
            using (sw)
            {
                HtmlTextWriter htmlWrite = new HtmlTextWriter(sw);
                using (htmlWrite)
                {
                    control.RenderControl(htmlWrite);
                }
            }
            WriteExcel(sw, filename, endExecution);
        }

        /// <summary>
        /// Escreve e exibe um arquivo Excel (XLS)
        /// </summary>
        /// <param name="write">Conteúdo a ser renderizado</param>
        /// <param name="filename">Nome de sugestão para o arquivo de Download</param>
        /// <param name="endExecution">Indica se após a geração do arquivo, termina a execução da página (Response.End)</param>
        public static void WriteExcel(TextWriter write, string filename, bool endExecution)
        {
            if (String.IsNullOrEmpty(filename))
                filename = "FileExport";

            var context = HttpContext.Current;
            context.Response.Clear();
            context.Response.AddHeader("content-disposition", "attachment;filename=" + filename + ".xls");
            context.Response.Charset = "";
            context.Response.Cache.SetCacheability(HttpCacheability.NoCache);
            context.Response.ContentType = "application/vnd.xls";
            context.Response.ContentEncoding = System.Text.Encoding.GetEncoding("ISO-8859-1");
            context.Response.Write(write);

            if (endExecution)
                context.Response.End();
        }

        /// <summary>
        /// Método que converte uma Imagem em um Array de Bytes
        /// </summary>
        /// <param name="fUpload"></param>
        /// <returns></returns>
        public static byte[] ConvertImageBytes(FileUpload fUpload)
        {
            byte[] imgbyte;

            if (fUpload.HasFile)
            {
                //obtem o tamanho da imagem enviada
                int tamanho = fUpload.PostedFile.ContentLength;
                //cria um array de bytes para armazenar os dados binários da imagem
                imgbyte = new byte[tamanho];
                //armazena a imagem selecinada na memória
                HttpPostedFile img = fUpload.PostedFile;
                //define os dados binários
                img.InputStream.Read(imgbyte, 0, tamanho);
            }
            else
            {
                imgbyte = null;
            }
            return imgbyte;
        }

        /// <summary>
        /// Método que Habilita ou Desabilita todos os controles da tela.
        /// </summary>
        public static void EnabledControls(Control control, bool enabled)
        {
            foreach (Control ctrl in control.Controls)
            {
                if (ctrl is TextBox)
                {
                    ((TextBox)ctrl).Enabled = enabled;
                }
                if (ctrl is DropDownList)
                {
                    ((DropDownList)ctrl).Enabled = enabled;
                }
                if (ctrl is RadioButtonList)
                {
                    ((RadioButtonList)ctrl).Enabled = enabled;
                }
                if (ctrl is CheckBox)
                {
                    ((CheckBox)ctrl).Enabled = enabled;
                }
                if (ctrl is RadioButton)
                {
                    ((RadioButton)ctrl).Enabled = enabled;
                }
                if (ctrl is ImageButton)
                {
                    ((ImageButton)ctrl).Enabled = enabled;
                }
                if (ctrl is Button)
                {
                    ((Button)ctrl).Enabled = enabled;
                }
                if (ctrl is FileUpload)
                {
                    ((FileUpload)ctrl).Enabled = enabled;
                }
                //if (ctrl is GridView)
                //{
                //    GridView gvw = new GridView();
                //    gvw = ((GridView)ctrl);
                //    gvw.DataSource = null;
                //    gvw.DataBind();
                //}
                if (ctrl.Controls.Count > 0)
                    EnabledControls(ctrl, enabled);
            }
        }

        public static void ClearControls(Control control)
        {
            foreach (Control ctrl in control.Controls)
            {

                if (ctrl is TextBox)
                {
                    ((TextBox)ctrl).Text = string.Empty;
                }
                if (ctrl is DropDownList)
                {
                    ((DropDownList)ctrl).SelectedIndex = -1;
                }
                if (ctrl is RadioButtonList)
                {
                    ((RadioButtonList)ctrl).SelectedIndex = -1;
                }
                if (ctrl is CheckBox)
                {
                    ((CheckBox)ctrl).Checked = false;
                }
                if (ctrl is RadioButton)
                {
                    ((RadioButton)ctrl).Checked = false;
                }
                if (ctrl is CheckBoxList)
                {
                    ((CheckBoxList)ctrl).SelectedIndex = -1;
                }
                if (ctrl.Controls.Count > 0)
                    ClearControls(ctrl);
            }
        }

        /// <summary>
        /// Exibe caixa de mensagens.
        /// </summary>
        /// <param name="message">Mensagem a ser exibida.</param>
        public static void ShowMessageBox(string message)
        {
            ShowMessageBox(message, PresentationConstants.DefaultTitleForMessageBox, true, true);
        }

        /// <summary>
        /// Exibe caixa de mensagens.
        /// </summary>
        /// <param name="message">Mensagem a ser exibida.</param>
        /// <param name="title">Titulo da caixa de mensagens.</param>
        public static void ShowMessageBox(string message, string title, bool isLogged)
        {
            ShowMessageBox(message, title, true, isLogged);
        }

        /// <summary>
        /// Exibe caixa de mensagens.
        /// </summary>
        /// <param name="message">Mensagem a ser exibida.</param>
        /// <param name="title">Titulo da caixa de mensagens.</param>
        /// <param name="encloseWithParagraph">Indica se é para colocar parágrafo ao redor do conteúdo.</param>
        public static void ShowMessageBox(string message, string title, bool encloseWithParagraph, bool isLogged)
        {
            GetMainMasterPage().ShowMessageBox(message, title, encloseWithParagraph);
        }

        #endregion
    }
}
